Кажется, сегодня я понял почему ФП это ООП для бедных, и наоборот Но трейд не совсем об этом.

В ООП все методы распределены по объектам, там-же находятся и данные. В ФП функции(а так-же процедуры в ПП) и данные существуют отдельно, к тому-же функции могут быть разбросаны по программе как угодно(не считая ограничений вносимых областями видимости имён).

Пример на Scala(с ошибками и который можно переписать проще):

   class T(t:Int) extends Int{
     val v = if(t > 100) 100 else t
     def size():Int = 100
     def add(a:T):T = {val s = a + v; (if(s > 100) 100 else s).asInstanceOf[T]}
     overrid def toString():String = v + "%"
   }
   class Main{
     def main(){
       val t = new T(1)
       val sz = t.size 
       val sm = t add new T(2)
       println(  sz + "," + sm  )
     }
   }

Пример на функционально-императивный ЯП, который я сейчас пилю:

   T DATA 0..100                                                        //Примитивный(как например int,boolean в Java) тип данных, заданный в виде диапазона.
   //
   T>Int = {t) t #> Int (}:Typecast                                     //Несколько тайпкастов для типа "T", чтоб не захламлять код явными приведениями.  
   Int>T = {i) (if i > 100 => 100 else => i) #> T (}:Typecast           //"#>" - оператор преобразования типов, как в Паскале.         
   T>Str = {t) t:Int:Str + "%" (}:Typecast     
   //
   size = {T) 100 (Int}                                                 //Функция "size"
   + = {a:T,b:T) a:Int + b:Int (T}                                      //Функция "+" 
   //
   t = 1:T                                                              //Определение значения типа T.
   sz = t.size()                                                        //Сахар для: sz = size(t) 
   sm = t + 2:T                                                         //Сахар для: sm = +(t,2:T) 
   print(  sz + "," + sm  )

Сей ЯП ориентирован на быстрое написание несложных, небольших программ (как Python). В данном контексте, думаю такой, гибридный ЯП будет лучшим выбором чем ООЯП, так как он несколько проще и гибче. Во первых — здесь данные и функции разделены, что будет проще для понимания людьми не знакомыми с ОО парадигмой (типа "вот у нас циферки и буковки, а вот у нас команды которые чего-то с ними делают"). Во вторых — не нужно особо структурировать программу, т.е. распределять функции и данные по классам, "пишем где удобно". Ну и в третьих — чтобы добавить какие-то новые методы для работы некоторым типом не нужно расширять класс, можно просто определить эти методы там где они нужны.

Собственно вопрос: Как вы считаете, верен ли мой выбор? Почему?

Спасибо.