Don't like ads? PRO users don't see any ads ;-)
Public Pastes
Guest

Untitled

By: a guest on May 4th, 2012  |  syntax: None  |  size: 17.60 KB  |  hits: 15  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  1. /* Prelude.cs : What happens when a haskell programmer learns C#.
  2.    Copyright (c) 2011 Clark Gaebel
  3.  
  4.    Permission is hereby granted, free of charge, to any person obtaining
  5.    a copy of this software and associated documentation files (the "Software"),
  6.    to deal in the Software without restriction, including without limitation
  7.    the rights to use, copy, modify, merge, publish, distribute, sublicense,
  8.    and/or sell copies of the Software, and to permit persons to whom the
  9.    Software is furnished to do so, subject to the following conditions:
  10.  
  11.    The above copyright notice and this permission notice shall be included
  12.    in all copies or substantial portions of the Software.
  13.  
  14.    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15.    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16.    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  17.    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  18.    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  19.    CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  20. */
  21.  
  22. using System;
  23. using System.IO;
  24. using System.Collections.Generic;
  25. using System.Diagnostics;
  26. using System.Linq;
  27. using System.Threading.Tasks;
  28.  
  29. namespace Functional
  30. {
  31.     // Easymode usage of Prelude: inherit from it. I _would_ declare it a static class
  32.     // (since that's what it really is), but then you have to prefix each name with
  33.     // "Prelude." and I'm just way too lazy for that.
  34.     public class Prelude
  35.     {
  36.         // Returns an empty list.
  37.         public static IEnumerable<T> Null<T>()
  38.         {
  39.             yield break;
  40.         }
  41.  
  42.         // This version of cons is prefereable, since the second argument is
  43.         // evaluated after the first. This allows for infinite lists and truly
  44.         // lazy computation.
  45.         public static IEnumerable<T> cons<T>(T y, Func<IEnumerable<T>> xs)
  46.         {
  47.             yield return y;
  48.             foreach (var x in xs()) yield return x;
  49.         }
  50.  
  51.         // However, if the second argument is something that could be computed
  52.         // eagerly (such as Null<T>), then it's fine to use this version of cons.
  53.         // It leads to cleaner invocation.
  54.         public static IEnumerable<T> cons<T>(T y, IEnumerable<T> xs)
  55.         {
  56.             return cons(y, () => xs);
  57.         }
  58.  
  59.         public static IEnumerable<R> map<T, R>(Func<T, R> f, IEnumerable<T> xs)
  60.         {
  61.             if (empty(xs)) return Null<R>();
  62.             return         cons(f(head(xs)), () => map(f, tail(xs)));
  63.         }
  64.  
  65.         public static IEnumerable<R> pmap<T, R>(Func<T, R> f, IEnumerable<T> xs)
  66.         {
  67.             return eval(xs.AsParallel().Select(f));
  68.         }
  69.  
  70.         public static void consume<T>(Action<T> f, IEnumerable<T> xs)
  71.         {
  72.             foreach (var x in xs) f(x);
  73.         }
  74.  
  75.         // Returns a list of elements for which `f' returns true.
  76.         public static IEnumerable<T> filter<T>(Func<T, bool> f, IEnumerable<T> xs)
  77.         {
  78.             if (empty(xs))   return Null<T>();
  79.             if (f(head(xs))) return cons(head(xs), () => filter(f, tail(xs)));
  80.             else             return filter(f, tail(xs));
  81.         }
  82.  
  83.         public static Func<I, O> compose<I, M, O>(Func<M, O> outer, Func<I, M> inner)
  84.         {
  85.             return x => outer(inner(x));
  86.         }
  87.  
  88.         public static Func<I2, I1, R> flip<I1, I2, R>(Func<I1, I2, R> f)
  89.         {
  90.             return (x, y) => f(y, x);
  91.         }
  92.  
  93.         public static T id<T>(T x) { return x; }
  94.  
  95.         public static IEnumerable<Tuple<T1, T2>> zip<T1, T2>(IEnumerable<T1> xs, IEnumerable<T2> ys)
  96.         {
  97.             return zipWith(Tuple.Create, xs, ys);
  98.         }
  99.  
  100.         public static IEnumerable<R> zipWith<T1, T2, R>(Func<T1, T2, R> f, IEnumerable<T1> xs, IEnumerable<T2> ys)
  101.         {
  102.             if (empty(xs) || empty(ys)) return Null<R>();
  103.             else                        return cons(
  104.                                                 f(head(xs), head(ys)),
  105.                                                 () => zipWith(f, tail(xs), tail(ys)));
  106.         }
  107.  
  108.         public static Tuple<IEnumerable<T1>, IEnumerable<T2>> unzip<T1, T2>(IEnumerable<Tuple<T1, T2>> xs)
  109.         {
  110.             return Tuple.Create(map(fst, xs), map(snd, xs));
  111.         }
  112.  
  113.         // Equivalent to the haskell: [start, (start + step) .. end]
  114.         // If end is -1, the list created is infinite.
  115.         public static IEnumerable<Int32> range(Int32 start, Int32 end = -1, Int32 step = 1)
  116.         {
  117.             if (end == -1) return iterate(x => x += step, start);
  118.  
  119.             Func<Int32, bool> condition = x => step < 0
  120.                                                 ? end <= x
  121.                                                 : x <= end;
  122.  
  123.             return takeWhile(condition, iterate(x => x += step, start));
  124.         }
  125.  
  126.         public static T head<T>(IEnumerable<T> xs)
  127.         {
  128.             Debug.Assert(!empty(xs), "Prelude.head: empty list");
  129.             var e = xs.GetEnumerator(); e.MoveNext();
  130.             return e.Current;
  131.         }
  132.  
  133.         public static IEnumerable<T> tail<T>(IEnumerable<T> xs)
  134.         {
  135.             Debug.Assert(!empty(xs), "Prelude.tail: empty list");
  136.             var e = xs.GetEnumerator(); e.MoveNext();
  137.             while(e.MoveNext()) yield return e.Current;
  138.         }
  139.  
  140.         public static IEnumerable<T> init<T>(IEnumerable<T> xs)
  141.         {
  142.             Debug.Assert(!empty(xs), "Prelude.init: empty list");
  143.  
  144.             var slow = xs.GetEnumerator();
  145.             var fast = xs.GetEnumerator(); fast.MoveNext();
  146.  
  147.             while (fast.MoveNext())
  148.             {
  149.                 slow.MoveNext();
  150.                 yield return slow.Current;
  151.             }
  152.         }
  153.  
  154.         public static T last<T>(IEnumerable<T> xs)
  155.         {
  156.             Debug.Assert(!empty(xs), "Prelude.last: empty list");
  157.  
  158.             var slow = xs.GetEnumerator();
  159.             var fast = xs.GetEnumerator();
  160.  
  161.             while(fast.MoveNext()) slow.MoveNext();
  162.  
  163.             return slow.Current;
  164.         }
  165.  
  166.         public static O foldl<I, O>(Func<O, I, O> f, O z, IEnumerable<I> xs)
  167.         {
  168.             O res = z;
  169.  
  170.             foreach (var x in xs)
  171.                 z = f(z, x);
  172.  
  173.             return z;
  174.         }
  175.  
  176.         public static O foldr<I, O>(Func<I, O, O> f, O z, IEnumerable<I> xs)
  177.         {
  178.             if (empty(xs)) return z;
  179.             return f(head(xs), foldr(f, z, tail(xs)));
  180.         }
  181.  
  182.         public static T foldl1<T>(Func<T, T, T> f, IEnumerable<T> xs)
  183.         {
  184.             Debug.Assert(!empty(xs), "Prelude.foldl1: empty list");
  185.             return foldl(f, head(xs), tail(xs));
  186.         }
  187.  
  188.         public static T foldr1<T>(Func<T, T, T> f, IEnumerable<T> xs)
  189.         {
  190.             Debug.Assert(!empty(xs), "Prelude.foldr1: empty list");
  191.             return foldr(f, head(xs), tail(xs));
  192.         }
  193.  
  194.         public static IEnumerable<T1> scanl<T1, T2>(Func<T1, T2, T1> f, T1 q, IEnumerable<T2> xs)
  195.         {
  196.             T1 res = q;
  197.             yield return res;
  198.  
  199.             foreach (var x in xs)
  200.             {
  201.                 res = f(res, x);
  202.                 yield return res;
  203.             }
  204.         }
  205.  
  206.         public static IEnumerable<T> scanl1<T>(Func<T, T, T> f, IEnumerable<T> xs)
  207.         {
  208.             if (empty(xs)) return Null<T>();
  209.             return scanl(f, head(xs), tail(xs));
  210.         }
  211.  
  212.         public static IEnumerable<T2> scanr<T1, T2>(Func<T1, T2, T2> f, T2 q0, IEnumerable<T1> xs)
  213.         {
  214.             if (empty(xs)) return cons(q0, Null<T2>());
  215.  
  216.             var qs = scanr(f, q0, tail(xs));
  217.             return cons(f(head(xs), head(qs)), () => qs);
  218.         }
  219.  
  220.         public static IEnumerable<T> scanr1<T>(Func<T, T, T> f, IEnumerable<T> xs)
  221.         {
  222.             if (empty(xs)) return Null<T>();
  223.             return scanr(f, last(xs), init(xs));
  224.         }
  225.  
  226.         public static IEnumerable<T> iterate<T>(Func<T, T> f, T x)
  227.         {
  228.             return cons(x, () => iterate(f, f(x)));
  229.         }
  230.  
  231.         // repeat x is an infinite list, with x the value of every element
  232.         public static IEnumerable<T> repeat<T>(T x)
  233.         {
  234.             return cons(x, () => repeat(x));
  235.         }
  236.  
  237.         // Cycle ties a finite list into a circular one, or equivalently,
  238.         // the infinite repetition of the original list. It is the identity
  239.         // on infinite lists.
  240.         public static IEnumerable<T> cycle<T>(IEnumerable<T> xs)
  241.         {
  242.             Debug.Assert(!empty(xs), "Prelude.cycle: empty list");
  243.  
  244.             for(;;) foreach(var x in xs) yield return x;
  245.         }
  246.  
  247.         public static IEnumerable<T> take<T>(int n, IEnumerable<T> xs)
  248.         {
  249.             return map(snd, takeWhile(nx => fst(nx) < n, zip(range(0), xs)));
  250.         }
  251.  
  252.         public static IEnumerable<T> drop<T>(int n, IEnumerable<T> xs)
  253.         {
  254.             return map(snd, dropWhile(nx => fst(nx) < n, zip(range(0), xs)));
  255.         }
  256.  
  257.         public static Tuple<IEnumerable<T>, IEnumerable<T>> splitAt<T>(int n, IEnumerable<T> xs)
  258.         {
  259.             return Tuple.Create(take(n, xs), drop(n, xs));
  260.         }
  261.  
  262.         public static IEnumerable<T> takeWhile<T>(Func<T, bool> f, IEnumerable<T> xs)
  263.         {
  264.             if (empty(xs)) return Null<T>();
  265.             if (!f(head(xs))) return Null<T>();
  266.             return cons(head(xs), () => takeWhile(f, tail(xs)));
  267.         }
  268.  
  269.         public static IEnumerable<T> dropWhile<T>(Func<T, bool> f, IEnumerable<T> xs)
  270.         {
  271.             if (empty(xs)) return Null<T>();
  272.             if (!f(head(xs))) return xs;
  273.             return dropWhile(f, tail(xs));
  274.         }
  275.  
  276.         public static Tuple<IEnumerable<T>, IEnumerable<T>> span<T>(Func<T, bool> f, IEnumerable<T> xs)
  277.         {
  278.             return Tuple.Create(takeWhile(f, xs), dropWhile(f, xs));
  279.         }
  280.  
  281.         public static Tuple<IEnumerable<T>, IEnumerable<T>> Break<T>(Func<T, bool> f, IEnumerable<T> xs)
  282.         {
  283.             return span(compose(x => !x, f), xs);
  284.         }
  285.  
  286.         public static IEnumerable<T> reverse<T>(IEnumerable<T> xs)
  287.         {
  288.             return foldl((ys, y) => cons(y, () => ys), Null<T>(), xs);
  289.         }
  290.  
  291.         public static bool any<T>(Func<T, bool> f, IEnumerable<T> xs)
  292.         {
  293.             if (empty(xs))   return false;
  294.             if (f(head(xs))) return true;
  295.             else             return any(f, tail(xs));
  296.         }
  297.  
  298.         public static bool all<T>(Func<T, bool> f, IEnumerable<T> xs)
  299.         {
  300.             if (empty(xs))    return true;
  301.             if (!f(head(xs))) return false;
  302.             else              return all(f, tail(xs));
  303.         }
  304.  
  305.         public static T1 fst<T1, T2>(Tuple<T1, T2> t) { return t.Item1; }
  306.         public static T2 snd<T1, T2>(Tuple<T1, T2> t) { return t.Item2; }
  307.  
  308.         public static IEnumerable<T> concat<T>(IEnumerable<T> xs, Func<IEnumerable<T>> ys)
  309.         {
  310.             if (empty(xs)) return ys();
  311.             else           return cons(head(xs), () => concat(tail(xs), ys));
  312.         }
  313.  
  314.         public static IEnumerable<T> concat<T>(IEnumerable<IEnumerable<T>> xss)
  315.         {
  316.             if (empty(xss)) return Null<T>();
  317.             else            return concat(head(xss), () => concat(tail(xss)));
  318.         }
  319.  
  320.         public static IEnumerable<T2> concatMap<T1, T2>(Func<T1, IEnumerable<T2>> f, IEnumerable<T1> xs)
  321.         {
  322.             return concat(map(f, xs));
  323.         }
  324.  
  325.         // TODO: words, unwords
  326.  
  327.         public static IEnumerable<String> lines(String s)
  328.         {
  329.             return s.Split('\n');
  330.         }
  331.  
  332.         public static IEnumerable<Char> unlines(IEnumerable<String> xs)
  333.         {
  334.             return concatMap(x => x + "\n", xs);
  335.         }
  336.  
  337.         public static bool empty<T>(IEnumerable<T> xs)
  338.         {
  339.             return !xs.GetEnumerator().MoveNext();
  340.         }
  341.  
  342.         public static int length<T>(IEnumerable<T> xs)
  343.         {
  344.             return foldl((x, _) => x + 1, 0, xs);
  345.         }
  346.  
  347.         // Uses a disposable resource with a function `user'.
  348.         public static T2 use<T1, T2>(T1 used, Func<T1, T2> user) where T1:IDisposable
  349.         {
  350.             using (used) return user(used);
  351.         }
  352.  
  353.         public static bool elem<T>(IEquatable<T> x, IEnumerable<IEquatable<T>> xs)
  354.         {
  355.             return any(y => y == x, xs);
  356.         }
  357.  
  358.         public static bool notElem<T>(IEquatable<T> x, IEnumerable<IEquatable<T>> xs)
  359.         {
  360.             return all(y => y != x, xs);
  361.         }
  362.  
  363.         public static IEnumerable<IComparable<T>> sort<T>(IEnumerable<IComparable<T>> xs)
  364.         {
  365.             var e = eval(xs);
  366.             Array.Sort(e);
  367.             return e;
  368.         }
  369.  
  370.         // Returns the lazy list as an eager list.
  371.         public static T[] eval<T>(IEnumerable<T> xs)
  372.         {
  373.             return xs.ToArray();
  374.         }
  375.  
  376.         public static Tuple<T1[], T2[]> eval<T1, T2>(Tuple<IEnumerable<T1>, IEnumerable<T2>> xs)
  377.         {
  378.             return Tuple.Create(eval(fst(xs)), eval(snd(xs)));
  379.         }
  380.  
  381.         public static T eval<T>(Func<T> f)
  382.         {
  383.             return f();
  384.         }
  385.  
  386.         #region curry overloads
  387.  
  388.         public static Func<R> curry<I1, R>(Func<I1, R> f, I1 v)
  389.         {
  390.             return () => f(v);
  391.         }
  392.  
  393.         public static Func<I2, R> curry<I1, I2, R>(Func<I1, I2, R> f, I1 v)
  394.         {
  395.             return (x1) => f(v, x1);
  396.         }
  397.  
  398.         public static Func<I2, I3, R> curry<I1, I2, I3, R>(Func<I1, I2, I3, R> f, I1 v)
  399.         {
  400.             return (x1, x2) => f(v, x1, x2);
  401.         }
  402.  
  403.         public static Func<I2, I3, I4, R> curry<I1, I2, I3, I4, R>(Func<I1, I2, I3, I4, R> f, I1 v)
  404.         {
  405.             return (x1, x2, x3) => f(v, x1, x2, x3);
  406.         }
  407.  
  408.         public static Func<I2, I3, I4, I5, R> curry<I1, I2, I3, I4, I5, R>(Func<I1, I2, I3, I4, I5, R> f, I1 v)
  409.         {
  410.             return (x1, x2, x3, x4) => f(v, x1, x2, x3, x4);
  411.         }
  412.  
  413.         public static Func<I2, I3, I4, I5, I6, R> curry<I1, I2, I3, I4, I5, I6, R>(Func<I1, I2, I3, I4, I5, I6, R> f, I1 v)
  414.         {
  415.             return (x1, x2, x3, x4, x5) => f(v, x1, x2, x3, x4, x5);
  416.         }
  417.  
  418.         public static Func<I2, I3, I4, I5, I6, I7, R> curry<I1, I2, I3, I4, I5, I6, I7, R>(Func<I1, I2, I3, I4, I5, I6, I7, R> f, I1 v)
  419.         {
  420.             return (x1, x2, x3, x4, x5, x6) => f(v, x1, x2, x3, x4, x5, x6);
  421.         }
  422.  
  423.         public static Func<I2, I3, I4, I5, I6, I7, I8, R> curry<I1, I2, I3, I4, I5, I6, I7, I8, R>(Func<I1, I2, I3, I4, I5, I6, I7, I8, R> f, I1 v)
  424.         {
  425.             return (x1, x2, x3, x4, x5, x6, x7) => f(v, x1, x2, x3, x4, x5, x6, x7);
  426.         }
  427.  
  428.         public static Func<I2, I3, I4, I5, I6, I7, I8, I9, R> curry<I1, I2, I3, I4, I5, I6, I7, I8, I9, R>(Func<I1, I2, I3, I4, I5, I6, I7, I8, I9, R> f, I1 v)
  429.         {
  430.             return (x1, x2, x3, x4, x5, x6, x7, x8) => f(v, x1, x2, x3, x4, x5, x6, x7, x8);
  431.         }
  432.  
  433.         public static Func<I2, I3, I4, I5, I6, I7, I8, I9, I10, R> curry<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, R>(Func<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, R> f, I1 v)
  434.         {
  435.             return (x1, x2, x3, x4, x5, x6, x7, x8, x9) => f(v, x1, x2, x3, x4, x5, x6, x7, x8, x9);
  436.         }
  437.  
  438.         public static Func<I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, R> curry<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, R>(Func<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, R> f, I1 v)
  439.         {
  440.             return (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) => f(v, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10);
  441.         }
  442.  
  443.         public static Func<I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, R> curry<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, R>(Func<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, R> f, I1 v)
  444.         {
  445.             return (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) => f(v, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11);
  446.         }
  447.  
  448.         public static Func<I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, R> curry<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, R>(Func<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, R> f, I1 v)
  449.         {
  450.             return (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) => f(v, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12);
  451.         }
  452.  
  453.         public static Func<I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, R> curry<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, R>(Func<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, R> f, I1 v)
  454.         {
  455.             return (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) => f(v, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13);
  456.         }
  457.  
  458.         public static Func<I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, R> curry<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, R>(Func<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, R> f, I1 v)
  459.         {
  460.             return (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) => f(v, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14);
  461.         }
  462.  
  463.         public static Func<I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, R> curry<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, R>(Func<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, R> f, I1 v)
  464.         {
  465.             return (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) => f(v, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15);
  466.         }
  467.  
  468.         #endregion
  469.  
  470.         // PRELUDE IO
  471.  
  472.         public static IEnumerable<char> readFileStream(StreamReader s)
  473.         {
  474.             char[] buffer = new char[4096];
  475.             int read;
  476.            
  477.             while((read = s.Read(buffer, 0, 4096)) > 0)
  478.             {
  479.                 for (int i = 0; i < read; ++i)
  480.                     yield return buffer[i];
  481.             }
  482.         }
  483.  
  484.         // lazy file input =)
  485.         public static IEnumerable<char> readFile(string path)
  486.         {
  487.             return use(File.OpenText(path), readFileStream);
  488.         }
  489.     }
  490. }
create a new version of this paste RAW Paste Data