Концепция называется Функция высшего порядка и является достаточно общей для функционального программирования.

Сами по себе функции - это всего лишь другой тип данных. Поэтому можно записывать функции, которые возвращают другие функции. Конечно, можно иметь функцию, которая принимает int в качестве параметра и возвращает что-то другое. Объедините их и рассмотрим следующий пример (на питоне):

def mult_by(a):
    def _mult_by(x):
        return x*a
    return mult_by

mult_by_3 = mult_by(3)

print mylt_by_3(3)
9

(извините за использование питона, но я не знаю f#)

Каноническим примером этого, вероятно, является "создатель сумматора" - функция, которая, учитывая число (например, 3), возвращает другую функцию, которая принимает целое число и добавляет к нему первое число.

Так, например, в псевдокоде

x = CreateAdder(3)
x(5) // returns 8
x(10) // returns 13
CreateAdder(20)(30) // returns 50

я недостаточно хорошо знаком с F #, чтобы пытаться написать его, не проверяя его, но C # будет примерно таким:

public static Func<int, int> CreateAdder(int amountToAdd)
{
    return x => x + amountToAdd;
}

Это поможет?

] РЕДАКТИРОВАТЬ: Как заметил Бруно, пример, который вы указали в своем вопросе, - это именно тот пример, для которого я привел код C #, поэтому приведенный выше псевдокод будет выглядеть следующим образом:

let x = f1 3
x 5 // Result: 8
x 10 // Result: 13
f1 20 30 // Result: 50

Это функция, которая принимает целое число и возвращает функцию, которая принимает целое число и возвращает целое.

Эта функция функционально эквивалентна функции, которая берет два целых числа и возвращает целое. Такой способ обращения с функциями, которые берут множественные параметры, распространен в функциональных языках и позволяет легко частично применить функцию к значению.

Например, предположим, что существует функция сложения, которая берет два целых числа и складывает их вместе:

let add x y = x + y

У вас есть список, и вы хотите добавить 10 к каждому элементу. Вы частично применяете функцию add к значению 10. Она привяжет один из параметров к 10 и оставит другой аргумент несвязанным.

let list = [1;2;3;4]
let listPlusTen = List.map (add 10)

Этот трюк делает составление функций очень простым и делает их очень многоразовыми. Как видите, вам не нужно писать другую функцию, которая добавляет 10 к элементам списка, чтобы передать его на карту . Вы только что повторно использовали функцию add.

Обычно вы интерпретируйте это как функцию, которая принимает два целых числа и возвращает целое число. Вы должны прочитать о каррировании .

функция, принимающая целое число, которая возвращает функцию, которая принимает целое число и возвращает целое число

Последняя часть:

функция, которая принимает целое число и возвращает целое число

должна быть довольно простой, C# пример:

public int Test(int takesAnInteger) { return 0; }

Итак, осталось

функция, принимающая целое число, которая возвращает (функция, подобная приведенной выше)

C# опять:

public int Test(int takesAnInteger) { return 0; }
public int Test2(int takesAnInteger) { return 1; }

public Func<int,int> Test(int takesAnInteger) {
    if(takesAnInteger == 0) {
        return Test;
    } else {
        return Test2;
    }
}

Ответ зависит конкретно от того, что вы имеете в виду под записями «top 1000 distinct».

Если вы хотите вернуть не более 1000 отдельных записей, независимо от количества дубликатов в таблице, напишите следующее:

SELECT DISTINCT TOP 1000 id, uname, tel
FROM Users
ORDER BY <sort_columns>

Если вы хотите найти только первые 1000 строк в таблице и потенциально вернуть гораздо меньше 1000 отдельных строк, вы бы написали это с помощью подзапроса или CTE, как это:

SELECT DISTINCT *
FROM
(
    SELECT TOP 1000 id, uname, tel
    FROM Users
    ORDER BY <sort_columns>
) u

Параметр ORDER BY является необязательным, если вас не волнует, какие записи вы вернете.

Вы правы, что должны использовать BroadcastReceiver .

Посмотрите на этот вопрос о перезапуске аварийных сигналов при модернизации ; В нем показано, как можно использовать ACTION _ PACKAGE _ REPLACED Намерение при обновлении приложения.

В F # (и многих других функциональных языках) существует понятие, называемое curried functions. Это то, что ты видишь. По существу, каждая функция принимает один аргумент и возвращает одно значение.

Сначала это кажется немного запутанным, потому что вы можете записать позвольте добавить x y = x + y и, похоже, добавить два аргумента. Но на самом деле исходная функция add принимает только аргумент x . При применении функция возвращает функцию, которая принимает один аргумент ( y ) и имеет уже заполненное значение x . После применения этой функции возвращается требуемое целое число.

Это отображается в сигнатуре типа. Думайте, что стрелка в сигнатуре типа означает «берет вещь с левой стороны и возвращает вещь с правой стороны». В типе int - > int - > int это означает, что он принимает аргумент типа int - целое число - и возвращает функцию типа int - > int - функцию, которая принимает целое число и возвращает целое число. Вы заметите, что это точно соответствует описанию того, как любопытные функции работают выше.

Вы можете прочитать

Типы функций F #: развлечения с кортежами и каррированием

Пример:

let fba = pown ab // fab = a ^ b

- функция, которая принимает int (показатель степени) и возвращает функцию, которая увеличивает свой аргумент до этой экспоненты, например

let sqr = f 2

или

let tohepowerofthree = f 3

so

sqr 5 = 25

tohepowerofthree 3 = 27

Здесь уже есть много ответов, но я хотел бы предложить еще один вариант. . Иногда объяснение одного и того же разными способами помогает вам «ощутить» это.

Мне нравится думать о функциях как «вы даете мне что-то, а я верну вам что-то другое»

Итак, Func говорит: «вы даете мне int , и я дам тебе строку ».

Мне также легче думать в терминах «позже»: « Когда вы дадите мне int, я дам вам строку». Это особенно важно, когда вы видите такие вещи, как myfunc = x => y => x + y (" Когда вы даете карри x, вы получаете то, что когда вы дадите ay вернет x + y ").

(Кстати, я предполагаю, что вы здесь знакомы с C #)

Итак, мы могли бы выразить ваш пример int -> int -> int как Func > .

Другой способ, которым я смотрю на int -> int -> int , заключается в том, что вы удаляете каждый элемент слева, предоставляя аргумент соответствующего типа. А когда у вас больше нет -> , у вас заканчивается «позднее», и вы получаете значение.

(Просто для удовольствия) вы можете преобразовать функцию, которая принимает все аргументы за один раз, в функцию, которая принимает их «постепенно» (официальный термин для их постепенного применения - «частичное применение»), это называется «каррирование» ':

static void Main()
{
    //define a simple add function
    Func<int, int, int> add = (a, b) => a + b;

    //curry so we can apply one parameter at a time
    var curried = Curry(add);    

    //'build' an incrementer out of our add function
    var inc = curried(1);         // (var inc = Curry(add)(1) works here too)
    Console.WriteLine(inc(5));    // returns 6
    Console.ReadKey();
}
static Func<T, Func<T, T>> Curry<T>(Func<T, T, T> f)
{
    return a => b => f(a, b);
}

Вот мои 2 c. По умолчанию функции F# позволяют частичное применение или currying. Это означает, что когда вы определяете это:

let adder a b = a + b;;

Вы определяете функцию, которая принимает целое число и возвращает функцию, которая принимает целое число и возвращает целое число или int -> int -> int. Керринг позволяет частично применить функцию для создания другой функции:

let twoadder = adder 2;;
//val it: int -> int

В приведенном выше коде a предопределено до 2, так что всякий раз, когда вы вызываете twoadder 3, он просто добавляет два к аргументу.

Синтаксис, в котором параметры функции разделяются пробелом, эквивалентен этому синтаксису лямбды:

let adder = fun a -> fun b -> a + b;;

Что является более читабельным способом понять, что две функции на самом деле соединены в цепочку.