Что делает->, означают в F#?

Это в основном значит "карты для". Считайте его, тот путь или как "преобразовывается в" или что-то как этот.

Так, от F# через 20 минут учебное руководство,

> List.map (fun x -> x % 2 = 0) [1 .. 10];;
val it : bool list
= [false; true; false; true; false; true; false; true; false; true]

код (забава i-> я % 2 = 0) определяет анонимную функцию, вызванную лямбда-выражение, которое имеет параметр x и функцию, возвращает результат "x % 2 = 0", который является, ровен ли x.

Первый вопрос - знакомы ли вы с лямбда-выражениями в C #? Если это так, то -> в F # совпадает с => в C # (я думаю, что вы читаете, он «идет»).

Оператор -> также можно найти в контексте сопоставления с образцом

match x with
| 1 -> dosomething
| _ -> dosomethingelse

Я не уверен, является ли это лямбда-выражением, или что-то еще, но я предполагаю, что 'идет к 'все еще держит.

Возможно, вы действительно имеете в виду «загадочные» ответы синтаксического анализатора F #:

> let add a b = a + b
val add: int -> int -> int

Это означает (как объясняет большинство примеров), что add - это «val», который занимает два целых и возвращает int. Для меня это было совершенно непрозрачно с самого начала. Я имею в виду, откуда мне знать, что add - это не val, который принимает одно целое и возвращает два целых?

Ну, в некотором смысле это так. Если я добавлю только один int, я получу обратно (int -> int):

> let inc = add 1
val inc: int -> int

Это (карри) - одна из вещей, которая делает F # такой сексуальной для меня.

Для полезной информации о F # я обнаружил, что блоги на FAR более полезны, чем любая официальная «документация»: вот некоторые имена, которые нужно проверить

• Дастин Кэмпбелл (это diditwith.net, цитируется в другом ответе)
• Дон Саймс («человек»)
• Tomasp.net (он же Томас Петричек )
• Эндрю Кеннеди (для единиц измерения)
• Fsharp.it (известный благодаря Проект Эйлера)
• http://lorgonblog.spaces.live.com/Blog (он же Брайан )
• Джомо Фишер

(-> b) означает "функцию от до b". В аннотации типа это обозначает функциональный тип. Например, f: (интервал-> Строка), означает, что f относится к функции, которая берет целое число и возвращает строку. Это также используется в качестве contstructor таких значений, как в

val f : (int -> int) = fun n -> n * 2

, который создает стоимость, которая является функцией от некоторого номера n до того же самого числа, умноженного на два.

Здесь уже есть много отличных ответов, я просто хочу добавить к разговору еще один способ размышления об этом.

'->' означает функцию.

'a ->' b - это функция, которая берет a и возвращает a b

('a *' b) -> ('c *' d) - функция который принимает кортеж типа ('a,' b) и возвращает кортеж ('c,' d). Например, int / string возвращает float / char.

То, где это становится интересным, находится в каскадном случае 'a ->' b -> 'c. Это функция, которая принимает 'a и возвращает функцию (' b -> 'c), или функцию, которая принимает' b -> 'c.

Так что если вы напишите: let fxyz = ()

Типом будет f: 'a ->' b -> 'c -> unit, поэтому, если вы применили только первый параметр, результат будет карри функция 'b ->' c -> '.

От Microsoft:

Функциональные типы являются типами, данными первоклассным значениям функции, и записаны интервал-> интервал. Они подобны делегату.NET типы, кроме они не имена. Все идентификаторы функции F# могут использоваться в качестве первоклассных значений функции, и стоимость анонимной функции может быть создана с помощью (забава...->...) форма выражения.

Много замечательных ответов на эти вопросы, спасибо людям. Я хотел бы поместить здесь редактируемый ответ, который объединяет вещи.

Для тех, кто знаком с пониманием C # -> то же самое, что и выражение> lamba - хороший первый шаг. Это использование: -

fun x y -> x + y + 1

Можно понимать как эквивалент: -

(x, y) => x + y + 1;

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

Следовательно, когда вышеизложенное описывается следующим образом: -

Int -> Int -> Int

Это действительно помогло узнать, что -> является правой ассоциативной, следовательно, вышеизложенное можно рассмотреть: -

Int -> (Int -> Int)

Ага! У нас есть функция, которая принимает Int и возвращает (Int -> Int) (карри функция?).

Также помогло объяснение, что -> может также появиться как часть определения типа. (Int -> Int) - это тип любой функции, которая принимает Int и возвращает Int.

Также полезно -> появляется в другом синтаксисе, таком как сопоставление, но там это не имеет того же значения? Это верно? Я не уверен, что это так. Я подозреваю, что это имеет то же значение, но у меня пока нет слов, чтобы выразить это.

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

В контексте определения функции это подобно => от лямбда-выражения в C# 3.0.

F#: let f = fun x -> x*x
C#: Func<int, int> f = x => x * x;

-> в F# также используется в сопоставлении с образцом, где это означает: если выражение соответствует части между | и ->, то то, что прибывает после ->, должно быть отдано как результат:

let isOne x = match x with
 | 1 -> true
 | _ -> false

Хорошая вещь в таких языках, как Haskell (в F # она очень похожа, но я не знаю точного синтаксиса - это должно помочь вам понять ->, однако) в том, что вы можете применять только части аргумента, для создания карри функций:

adder n x y = n + x + y

Другими словами: «дай мне три вещи, и я сложу их вместе». Когда вы кидаете числа в него, компилятор выводит типы n x и y. Допустим, вы пишете

adder 1 2 3

Тип 1, 2 и 3 Int. Поэтому:

adder :: Int -> Int -> Int -> Int

То есть, дайте мне три целых числа, и я стану целым числом, в конце концов, или то же самое, что и сказать:

five :: Int
five = 5

Но вот хорошая часть ! Попробуйте это:

add5 = adder 5

Как вы помните, сумматор принимает int, int, int и возвращает вам int. Однако это не вся правда, как вы скоро увидите. Фактически, add5 будет иметь такой тип:

add5 :: Int -> Int -> Int

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

addder :: Int -> (Int -> (Int -> Int))

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

add5andtwomore :: Int -> (Int -> Int)
add5andtwomore = adder 5

Теперь вы можете использовать add5andtwomore вместо «adder 5». Таким образом, вы можете применить другое целое число, чтобы получить (скажем) «add5and7andonemore»:

add5and7andonemore :: Int -> Int
add5and7andonemore = adder 5 7

Как видите, add5and7andonemore хочет точно другой аргумент, и когда вы его дадите, он внезапно станет целым числом!

  > add5and7andonemore 9
 => ((add5andtwomore) 7) 9
 => ((adder 5) 7) 9)
<=> adder 5 7 9

Подставляя параметры к сумматору (nxy) для (5 7 9), мы получаем:

  > adder 5 7 9 = 5 + 7 + 9
 => 5 + 7 + 9
 => 21

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

  > 5 + 7 + 9
 => (+ 5 (+ 7 9))
 => (+ 5 16)
 => 21

Вот, пожалуйста!