Comments for Steve Horsfield

Comment on F#: Composing Functions by Steve Horsfield

Steve Horsfield — Mon, 01 Apr 2013 06:34:27 +0000

Both are correct.
When using a pipeline operator, the function on the right must take at least one operand. Currying is the method of taking a tuple input function and translating it into a series of function generating lambdas. That function has a single argument, no longer a tuple, that leads to another function that also expects a single argument. This approach is the default for functional programming and leads to what we describe as partial application because we choose to disregard the additional internal functions, but each of those is a curried function because each input can be applied singularly.

The key here is that, usually, our function requires at least two arguments and these are supplied independently and not as a tuple. Only after we’ve applied one argument is it a partially applied function, but even this is not strictly required.

Comment on F#: Composing Functions by Shak

Shak — Sun, 31 Mar 2013 20:05:10 +0000

>In other words, the pipeline operator takes the left operand (in this case x) and applies it to the curried function given as its right operand.

Just for my own understanding, should that read “partially applied” instead of “curried”? As currying is an operation on functions (and all functions in F# are curried by default)?

Comment on F#: Composing Functions by F# Weekly #52, 2012 – New Year Edition « Sergey Tihon's Blog

F# Weekly #52, 2012 – New Year Edition « Sergey Tihon's Blog — Sun, 30 Dec 2012 21:01:31 +0000

[...] Steve Horsfield published “F#: Composing Functions“. [...]

Comment on Ten tips for using and configuring Kerberos authentication on Windows by Chrome almost supports SSO in Windows Kerberos environments « Steve Horsfield

Sun, 09 Oct 2011 13:46:30 +0000

[...] about Google Chrome was taken from here: HTTP authentication [The Chromium Projects]. See my recent post about Kerberos in Windows for links to supporting Windows implementation materials. [...]

Comment on NHibernate: How to filter on primitive collections by ivowiblo

ivowiblo — Tue, 23 Feb 2010 01:13:39 +0000

Hi,
In hql you have the elements word that should help you.

from the documentation (https://www.hibernate.org/hib_docs/nhibernate/html/queryhql.html#queryhql-expressions):

select mother from Eg.Cat as mother, Eg.Cat as kit
where kit in elements(mother.Kittens)

select p from Eg.NameList list, Eg.Person p
where p.Name = some elements(list.Names)

from Eg.Cat cat where exists elements(cat.Kittens)

from Eg.Player p where 3 > all elements(p.Scores)

from Eg.Show show where ‘fizard’ in indices(show.Acts)

Hope it helped!

Comment on F#: Composing Functions by Andrew Garman

Andrew Garman — Wed, 18 Nov 2009 00:08:50 +0000

Excellent summary of and examples of composition and pipelines in F#! There's also the triple pipeline operators: |||> <||| Also of note, F# type inference work best with forward pipelining and composition.

Comment on Worked Example: Programmatic Addition of a WPF Data Template to a Resource Dictionary by Steve Horsfield

Steve Horsfield — Thu, 22 Oct 2009 17:47:49 +0000

Glad to help, although I am not sure I did! You may be able to get around this by using your own dynamic assembly but you will probably need to wait until code generation is fully part of the .NET libraries — Microsoft are planning this, but it may be .NET 5.0 (or later!).

Comment on Worked Example: Programmatic Addition of a WPF Data Template to a Resource Dictionary by Matt

Matt — Thu, 22 Oct 2009 00:24:43 +0000

Thanks Steve, that is exactly what I am looking for.

Looks like I’m going to have to compile my custom dataTemplate :(

Cheers,
Matt

Comment on Worked Example: Programmatic Addition of a WPF Data Template to a Resource Dictionary by Steve Horsfield

Steve Horsfield — Wed, 21 Oct 2009 09:08:01 +0000

Hi Matt,

I am not sure you will be able to make it work (certainly not easily) because of the way FSI creates classes. In particular, you cannot use namespaces directly. Instead, FSI creates namespaces implicitly. Here is a very simple test using a clean FSI environment:

let docClass o = printf "%s (%s)\n" (o.GetType().FullName) (o.GetType().Assembly.FullName);;

type C() = member s.m() = ();;

module X = type D() = member s.m() = ();;

docClass (new C()) ; docClass (new X.D()) ;;

In my case, the response is:

FSI_0002+C (FSI-ASSEMBLY, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null) FSI_0009+X+D (FSI-ASSEMBLY, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null)

Further investigation shows that FSI creates a dynamic assembly that does not support the Assembly CodeBase property and so you are quite limited in how you can reference it.

I hope that helps a little. Let me know if I have misunderstood your problem.

Steve

Comment on Worked Example: Programmatic Addition of a WPF Data Template to a Resource Dictionary by Matt

Matt — Wed, 21 Oct 2009 08:28:01 +0000

Hi Steve,

I love this example, but I’m having a hard time getting it to work with new types specified in F# Interpreter (i.e. not in any assembly). Is there a namespace for the FSI that I can’t find? Or another way around this?

Much appreciated.

Matt