fork download 
  1. using System;
  2.  
  3. namespace Test {
  4.  
  5.     /* well
  6.        fuck
  7.      
  8.      // class Monad m where
  9.      public interface Mandadka {
  10.         // (>>=) :: m a -> (a -> m b) -> m b
  11.         Mandadka bind<A, B>( Func<A, B> Func );
  12.      
  13.         //(>>) :: m a -> m b -> m b
  14.         // unused
  15.      
  16.         // return :: a -> m a     
  17.         // Mandadka wrap<A>( A arg ); // it will be static
  18.      
  19.         // fail :: String -> m a     
  20.         // unused
  21.     }*/
  22.  
  23.     public class MaybeInternal<T> {
  24.         public enum TYPE {
  25.             Nothing,
  26.             Just
  27.         }
  28.  
  29.         public TYPE type { get; private set; }
  30.         public T value { get; private set; }
  31.  
  32.         public MaybeInternal( TYPE t ) {
  33.             if ( t != TYPE.Nothing ) throw new ArgumentException( "You forgot to pass value to Just constructor" );
  34.             type = t;
  35.         }
  36.  
  37.         public MaybeInternal( TYPE t, T value ) {
  38.             if ( t != TYPE.Just || value == null ) throw new ArgumentException( "shit happened" );
  39.             type = t;
  40.             this.value = value;
  41.         }
  42.     }
  43.  
  44.     public static class Maybe /*: Mandadka*/ {
  45.         public static MaybeInternal<B> bind<T, B>( this MaybeInternal<T> arg, Func<T, B> func ) where B:class {
  46.             B tmp = null;
  47.             if ( arg == null || arg.type == MaybeInternal<T>.TYPE.Nothing ) {
  48.                 return wrap<B>( tmp );
  49.             } else { // Just x
  50.                 return wrap<B>( func( arg.value ) );
  51.             }
  52.  
  53.         }
  54.  
  55.         public static MaybeInternal<B> wrap<B>( B arg ) {
  56.             if ( arg == null ) {
  57.                 return new MaybeInternal<B>( MaybeInternal<B>.TYPE.Nothing );
  58.             } else {
  59.                 return new MaybeInternal<B>( MaybeInternal<B>.TYPE.Just, arg );
  60.             }
  61.         }
  62.  
  63.         public static bool isNothing<T>( this MaybeInternal<T> a ) {
  64.             return ( a == null || a.type == MaybeInternal<T>.TYPE.Nothing );
  65.         }
  66.     }
  67.  
  68.     // test class
  69.     public class Person {
  70.         public string race;
  71.         public int dickLen;
  72.  
  73.         public Person( string race, int dickLen ) {
  74.             this.race = race;
  75.             this.dickLen = dickLen;
  76.         }
  77.     }
  78.  
  79.     class Program {
  80.         static void Main( string[] args ) {
  81.             Person first = new Person( "nigra", 20 );
  82.             Person second = null;
  83.  
  84.             Maybe.wrap( first )
  85.                 .bind( ( Person x ) => { x.dickLen++; return x; } )
  86.                 .bind( ( Person x ) => { x.race += "!"; return x; } )
  87.                 .bind( ( Person x ) => { Console.WriteLine( "{0} {1}", x.race, x.dickLen ); return x; } );
  88.  
  89.             Maybe.wrap( second )
  90.                 .bind( ( Person x ) => { x.dickLen++; return x; } )
  91.                 .bind( ( Person x ) => { x.race += "!"; return x; } )
  92.                 .bind( ( Person x ) => { Console.WriteLine( "{0} {1}", x.race, x.dickLen ); return x; } );
  93.         }
  94.     }
  95. }
  96.  
Success #stdin #stdout 0.03s 33736KB
comments (?)
stdin 
Standard input is empty
stdout 
nigra! 21
https://ideone.com/Bi24TD
language:
C# (gmcs 5.20.1)
created:
11 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!