juan_gandhi | Entries tagged with fprog

getRandomNumber(), как и функции getCurrentTime().

Это всё не функции. Случайное число - это переменная. Употребление getRandomNumber() делает ваш код зависимым от случайной переменной (тут прячется монада, но это неважно). Просто считайте, что у вас теперь есть функция, определённая на значениях, возвращаемых вашим getRandomNumber(). То же самое и про getCurrentTime() - это тоже не функция, а переменная. По которой, например, можно интегрировать.

frpog#5/F#:

Конвейерные операторы — передают значение, вычисленное одной функцией, на вход второй. Пожалуй, наиболее часто употребляемым оператором из этой группы можно назвать |>, определение которого выглядит так:

let (|>) x f = f x

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

let list = [1..10]
list
  |> List.map (fun i -> i*i)
  |> List.iter (fun sq -> printfn "Square: %d" sq)

Классная идейка-то. Как-то в скале не популяризуется; надо будет попробовать. Не знал раньше.


scala> abstract class N[T]                                                                                                                  
defined class N

scala> case class L[T](v:T) extends N[T]                                                                                 
defined class L

scala> case class B[T](kids:List[N[T]]) extends N[T]                                                                     
defined class B

scala> val t = B(List(B(List(L("ab"),L("cd"),B(List(L("xy"),L("z"))))),L("middle")))                                                        
t: B[java.lang.String] = B(List(B(List(L(ab), L(cd), B(List(L(xy), L(z))))), L(middle)))

scala> def scan[T](tree:N[T]):List[T] = tree match { case L(v) => List(v); case B(kids) => kids flatMap (scan(_)) } 
scan: [T](N[T])List[T]

scala> scan(t)                                                                                                                 
res17: List[java.lang.String] = List(ab, cd, xy, z, middle)

scala>

I used repl, so it's kind of too laconic; in real life you probaly won't call your class N, L and B. But you know what I mean, right?

I was experimenting with Set[T] functor variance. Here are my considerations regarding the opportunity to make it contravariant. In short: it's impossible.

    /**
     * Casts a set into a set of subtype (contravariance, that is)
     * This method does not work, due to JVM type erasure.
     * Actually, delegating the work to runtime would be a stupid idea anyway;
     * so, is it a general problem with oop? Have to think.
     */
    @Deprecated  
    /*implicit*/ def downshift[A, B >: A] (source: Set[B]) : Set[A] = {
      val b2a: (B => A) = {case (a: A) => a}
      val elements = {for (b <- source; if b.isInstanceOf[A]) yield b2a(b)}
      setOf(elements, source.size, source.contains _)
    }

So, what I am thinking. Can we make Set functor contravariant in OOP? I mean, we have two problems here:

Java type erasure makes it impossible to actually check the element type;

OOP in general forces us to delegate this type checking to runtime - which is, I assume, a wrong idea

Seems like variance just does not work here.

I'll continue investigating the opportunities for covariance.

S	M	T	W	T	F	S
1	2	3	4	5	6	7
8	9	10	11	12	13	14
15	16	17	18	19	20	21
22	23	24	25	26	27	28
29	30

Observations

Views from Souths

Entries tagged with fprog

нет такой функции...

оценил трубу

visitor pattern, scala sample

let me show you something

Profile

June 2025

Syndicate

Most Popular Tags

Page Summary

Active Entries

Style Credit

Expand Cut Tags