type By func(p1, p2 *Planet) bool

// Sort is a method on the function type, By, that sorts the argument slice according to the function.
func (by By) Sort(planets []Planet) {
	ps := &planetSorter{
		planets: planets,
		by:      by, // The Sort method's receiver is the function (closure) that defines the sort order.
	}
	sort.Sort(ps)
}

John Howard <******@****.***> 1706030446 -0800

LATEST_CONFIG=$(echo "${PUBLISHED_RELEASES}" | jq -r '[ .[] | select(.tag_name | startswith("cmd/config/v")) ] | sort_by(.published_at) | last | .tag_name | scan("\/(v[\\d.]+)") | .[0]')

		<dependency>
			<groupId>org.dbflute.utflute</groupId>
			<artifactId>utflute-lasta-di</artifactId>
			<version>${utflute.version}</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.mortbay.jetty</groupId>
			<artifactId>jetty</artifactId>
			<version>6.1.26</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-simple</artifactId>

// RUN: tf-opt %s -tfl-partitioned-topological-sort | FileCheck %s

// CHECK-LABEL: @tf_ops_will_be_partitioned
func.func @tf_ops_will_be_partitioned() -> tensor<1xf32> {
  %const = "tfl.pseudo_const"() {value = dense<[1.0]> : tensor<1xf32>} : () -> tensor<1xf32>
  %tmp1 = "tfl.add"(%const, %const) { fused_activation_function = "NONE" } : (tensor<1xf32>,tensor<1xf32>) -> (tensor<1xf32>)

        !sorted[1].description

        sorted[2].name == 'a:x:1.0 -> 2.0'
        !sorted[2].description

        sorted[3].name == 'a:x:1.5 -> 2.0'
        !sorted[3].description

        sorted[4].name == 'a:z:1.0'
        !sorted[4].description

        sorted[5].name == 'a:z:1.0'
        !sorted[5].description

        sorted[6].name == 'b:a:5.0'
        !sorted[6].description

func (d Data) Quantile(phi float64) float64 {
	return d.sorted().quantile(phi)
}

func (d Data) Quantiles(phis ...float64) []float64 {
	return d.sorted().quantiles(phis...)
}

func (d Data) Copy() Data {
	out := make(Data, 0, len(d))
	out = append(out, d...)
	return out
}

func (d Data) sorted() sorted {
	out := make(sorted, 0, len(d))
	out = append(out, d...)

	sort.Float64s(out)
	return out
}

			if c.after == "*" && len(sorted) > 0 {
				if curIdx := getRIndex(sorted, c.name); curIdx == -1 {
					sorted = append(sorted, c.name)
				}
			} else if sortedIdx := getRIndex(sorted, c.after); sortedIdx != -1 {
				if curIdx := getRIndex(sorted, c.name); curIdx == -1 {
					// if after callback sorted, append current callback to last
					sorted = append(sorted, c.name)
				} else if curIdx < sortedIdx {

        if (forcedVersion != null) {
            return sorted.subList(sorted.indexOf(forcedVersion), sorted.size());
        } else {
            return sorted;
        }
    }

    Set<ModuleResolveState> getParticipatingModules() {
        return participatingModules;
    }

    @Nullable
    public ComponentIdentifier getSelectedPlatformId() {
        ComponentState selected = platformModule.getSelected();

        when:
        def sorted = DependencyResultSorter.sort([d1, d2], versionSelectorScheme, versionComparator, versionParser)

        then:
        sorted == [d1, d2]
    }

    def "sorts by comparing ModuleComponentSelector on left and ProjectComponentSelector on right"() {