C# y el caracter Wildcard de Haskell

Escuchando al Dr. Meijer en su serie Functional Programming with Haskell, me topé con algo interesante: el caracter wildcard de Haskell. El "wildcard” (_) en Haskell es prácticamente lo mismo que el caracter wildcard (*) en nuestros sistemas operativos, evalúa o implica cualquier “otra cosa”. Por ejemplo:

(&&)         :: Bool -> Bool -> Bool
True && True = True
_ && _       = False

Tiene una interpretación sumamente sencilla: “Dada una función llamada &&, que toma un Bool y retorna una función que toma un Bool y retorna un Bool siendo sus parámetros True y True retornará True, de cualquier otra manera, retornará False”. A simple vista pensaremos que en lenguajes de “diario” no existen conceptos como el de “wildcard”, pero como lo dice luego el Dr. Meijer, en C# si tenemos el concepto de wildcard, claro, con nuestros amigos los Generics (otro concepto tomado de lenguajes funcionales y que data de muchos años atrás :P ).

En C# el guión bajo es un nombre aceptado de una variable, así que podemos utilizarlo como caracter de wildcard (a lo Haskell), imaginemos la declaración desiguiente tipo genérico:

public interface IRepository<T> {
    T GetById(int id);
}

Bien, que tal si lo nombramos algo así:

public interface IRepository<_> {
    _ GetById(int id);
}

Debo admitir que en mi caso lo veo algo extraño para los tipos de retorno… Que tal si usamos un wildcard para aquellos tipos que "debemos" definir pero que no "vamos" a utilizar.

// Siendo esta la declaración de un evento
runtime.RuntimeStarted += (sender, e) => Console.WriteLine(e.InstanceId);

// De igual manera, sender es un Object el cual no utilizamos
runtime.RuntimeStarted += (_, e) => Console.WriteLine(e.InstanceId);

Si, ya se que más de algún usuario de VB.NET me comentará que en VB9 no es necesario declarar en los eventos aquellos parámetros que no utilizaremos, pero esa es harina de otro costal.

Al parecer si hay un par de cosas que un usuario de C# puede aprender de Haskell… Saludos!

  • Pingback: C# y el caracter Wildcard de Haskell - IDisposable Thoughts... in asp.net :P

  • Pingback: Tweets that mention C# y el caracter Wildcard de Haskell | IDisposable Thoughts -- Topsy.com

  • http://bugsquash.blogspot.com/ Mauricio Scheffer

    Me parece que hay una diferencia fundamental: en los lenguajes funcionales el _ es especial, matchea cualquier cosa *pero no bindea* mientras que en C# sí bindea. Por ej, en F# se puede escribir:
    let m = Map.Create(StringComparer.InvariantCultureIgnoreCase, [(“one”, “uno”); (“two”, “dos”)])
    let a = m.ForAll (fun _ _ -> true)

    siendo cada _ de tipo distinto, y no hay problema.
    En haskell es lo mismo: “Each wild-card independently matches anything, but in contrast to a formal parameter, each binds nothing” (http://www.haskell.org/tutorial/patterns.html)

  • http://bugsquash.blogspot.com/ Mauricio Scheffer

    Me parece que hay una diferencia fundamental: en los lenguajes funcionales el _ es especial, matchea cualquier cosa *pero no bindea* mientras que en C# sí bindea. Por ej, en F# se puede escribir:
    let m = Map.Create(StringComparer.InvariantCultureIgnoreCase, [(“one”, “uno”); (“two”, “dos”)])
    let a = m.ForAll (fun _ _ -> true)

    siendo cada _ de tipo distinto, y no hay problema.
    En haskell es lo mismo: “Each wild-card independently matches anything, but in contrast to a formal parameter, each binds nothing” (http://www.haskell.org/tutorial/patterns.html)

    • http://www.cprieto.com cprieto

      Gracias Mauricio por la aclaración y tu comentario! (estoy aprendiendo Haskell :P )

  • Pingback: uberVU - social comments

  • http://bugsquash.blogspot.com/ Mauricio Scheffer

    Me parece que hay una diferencia fundamental: en los lenguajes funcionales el _ es especial, matchea cualquier cosa *pero no bindea* mientras que en C# sí bindea. Por ej, en F# se puede escribir:
    let m = Map<_,_,_>.Create(StringComparer.InvariantCultureIgnoreCase, [(“one”, “uno”); (“two”, “dos”)])
    let a = m.ForAll (fun _ _ -> true)

    siendo cada _ de tipo distinto, y no hay problema.
    En haskell es lo mismo: “Each wild-card independently matches anything, but in contrast to a formal parameter, each binds nothing” (http://www.haskell.org/tutorial/patterns.html)

  • http://www.cprieto.com cprieto

    Gracias Mauricio por la aclaración y tu comentario! (estoy aprendiendo Haskell :P )

  • http://www.cprieto.com cprieto

    Gracias Mauricio por la aclaración y tu comentario! (estoy aprendiendo Haskell :P )