The document introduces the Scala programming language, which aims to provide better support for component software by unifying object-oriented and functional programming. Key features of Scala include supporting both object-oriented and functional paradigms, static typing with local type inference, lightweight syntax for anonymous functions and pattern matching, and integration with XML. Scala also allows defining new control structures and uses traits similar to interfaces, mixins for composition, and views for coercion between types.
Principles of functional progrmming in scalaehsoon
a short outline on necessity of functional programming and principles of functional programming in Scala.
In the article some keyword are used but not explained (to keep the article short and simple), the interested reader can look them up in internet.
Traits in Scala are similar to interfaces, but much more powerful.➢A trait encapsulates method and field definitions, which can then bereused by mixing them into classes.
Principles of functional progrmming in scalaehsoon
a short outline on necessity of functional programming and principles of functional programming in Scala.
In the article some keyword are used but not explained (to keep the article short and simple), the interested reader can look them up in internet.
Traits in Scala are similar to interfaces, but much more powerful.➢A trait encapsulates method and field definitions, which can then bereused by mixing them into classes.
This ppt describes basics of scala upto collections covering both object oriented and functional programming concepts of the language.
References:Scala cookbook
Qcon2011 functions rockpresentation_scalaMichael Stal
This is the part I of the tutorial I planned to give at QCon 2011 on Functional Programming with Scala. It also includes Scala 2.8 as well as upcoming features
This presentation was presented at OSS camp in New Delhi. It deals with the basics of Scala language and how we can use it to build scalable Applications
Scala: Object-Oriented Meets Functional, by Iulian Dragos3Pillar Global
A presentation from Iulian Dragos of Typesafe that gives an overview of the Scala programming language. The presentation was given at a Functional Angle conference in Timisoara, Romania sponsored by 3Pillar. Iulian Dragos has been working on Scala since 2004. He currently works for Typesafe, a start-up that was co-founded by Scala’s creator, Martin Odersky.
This ppt describes basics of scala upto collections covering both object oriented and functional programming concepts of the language.
References:Scala cookbook
Qcon2011 functions rockpresentation_scalaMichael Stal
This is the part I of the tutorial I planned to give at QCon 2011 on Functional Programming with Scala. It also includes Scala 2.8 as well as upcoming features
This presentation was presented at OSS camp in New Delhi. It deals with the basics of Scala language and how we can use it to build scalable Applications
Scala: Object-Oriented Meets Functional, by Iulian Dragos3Pillar Global
A presentation from Iulian Dragos of Typesafe that gives an overview of the Scala programming language. The presentation was given at a Functional Angle conference in Timisoara, Romania sponsored by 3Pillar. Iulian Dragos has been working on Scala since 2004. He currently works for Typesafe, a start-up that was co-founded by Scala’s creator, Martin Odersky.
2024.06.01 Introducing a competency framework for languag learning materials ...Sandy Millin
http://sandymillin.wordpress.com/iateflwebinar2024
Published classroom materials form the basis of syllabuses, drive teacher professional development, and have a potentially huge influence on learners, teachers and education systems. All teachers also create their own materials, whether a few sentences on a blackboard, a highly-structured fully-realised online course, or anything in between. Despite this, the knowledge and skills needed to create effective language learning materials are rarely part of teacher training, and are mostly learnt by trial and error.
Knowledge and skills frameworks, generally called competency frameworks, for ELT teachers, trainers and managers have existed for a few years now. However, until I created one for my MA dissertation, there wasn’t one drawing together what we need to know and do to be able to effectively produce language learning materials.
This webinar will introduce you to my framework, highlighting the key competencies I identified from my research. It will also show how anybody involved in language teaching (any language, not just English!), teacher training, managing schools or developing language learning materials can benefit from using the framework.
Introduction to AI for Nonprofits with Tapp NetworkTechSoup
Dive into the world of AI! Experts Jon Hill and Tareq Monaur will guide you through AI's role in enhancing nonprofit websites and basic marketing strategies, making it easy to understand and apply.
Honest Reviews of Tim Han LMA Course Program.pptxtimhan337
Personal development courses are widely available today, with each one promising life-changing outcomes. Tim Han’s Life Mastery Achievers (LMA) Course has drawn a lot of interest. In addition to offering my frank assessment of Success Insider’s LMA Course, this piece examines the course’s effects via a variety of Tim Han LMA course reviews and Success Insider comments.
Normal Labour/ Stages of Labour/ Mechanism of LabourWasim Ak
Normal labor is also termed spontaneous labor, defined as the natural physiological process through which the fetus, placenta, and membranes are expelled from the uterus through the birth canal at term (37 to 42 weeks
Francesca Gottschalk - How can education support child empowerment.pptxEduSkills OECD
Francesca Gottschalk from the OECD’s Centre for Educational Research and Innovation presents at the Ask an Expert Webinar: How can education support child empowerment?
Model Attribute Check Company Auto PropertyCeline George
In Odoo, the multi-company feature allows you to manage multiple companies within a single Odoo database instance. Each company can have its own configurations while still sharing common resources such as products, customers, and suppliers.
Read| The latest issue of The Challenger is here! We are thrilled to announce that our school paper has qualified for the NATIONAL SCHOOLS PRESS CONFERENCE (NSPC) 2024. Thank you for your unwavering support and trust. Dive into the stories that made us stand out!
2. Why a new language?
Goal was to create a language with better support
for component software
Two hypotheses:
Programming language for component software
should be scalable
The same concepts describe small and large parts
Rather than adding lots of primitives, focus is on
abstraction, composition, and decomposition
Language that unifies OOP and functional
programming can provide scalable support for
components
Adoption is key for testing this hypothesis
Scala interoperates with Java and .NET
3. Features of Scala
Scala is both functional and object-oriented
every value is an object
every function is a value--including methods
Scala is statically typed
includes a local type inference system:
in Java 1.5:
Pair p = new Pair<Integer, String>(1, "Scala");
in Scala:
val p = new MyPair(1, "scala");
4. More features
Supports lightweight syntax for anonymous
functions, higher-order functions, nested
functions, currying
ML-style pattern matching
Integration with XML
can write XML directly in Scala program
can convert XML DTD into Scala class
definitions
Support for regular expression patterns
5. Other features
Allows defining new control structures
without using macros, and while
maintaining static typing
Any function can be used as an infix or
postfix operator
Can define methods named +, <= or ::
6. Automatic Closure Construction
Allows programmers to make their own
control structures
Can tag the parameters of methods with the
modifier def.
When method is called, the actual def
parameters are not evaluated and a no-
argument function is passed
7. While loop example
object TargetTest1 with Application {
def loopWhile(def cond: Boolean)(def body: Unit): Unit =
if (cond) {
body;
loopWhile(cond)(body);
}
var i = 10;
loopWhile (i > 0) {
Console.println(i);
i = i - 1
}
}
Define loopWhile method
Use it with nice syntax
9. Scala object system
Class-based
Single inheritance
Can define singleton objects easily
Subtyping is nominal
Traits, compound types, and views allow for
more flexibility
11. Traits
Similar to interfaces in Java
They may have implementations of methods
But can’t contain state
Can be multiply inherited from
12. Example of traits
trait Similarity {
def isSimilar(x: Any): Boolean;
def isNotSimilar(x: Any): Boolean = !isSimilar(x);
}
class Point(xc: Int, yc: Int) with Similarity {
var x: Int = xc;
var y: Int = yc;
def isSimilar(obj: Any) =
obj.isInstanceOf[Point] &&
obj.asInstanceOf[Point].x == x;
}
13. Mixin class composition
Basic inheritance model is single inheritance
But mixin classes allow more flexibility
class Point2D(xc: Int, yc: Int) {
val x = xc;
val y = yc;
// methods for manipulating Point2Ds
}
class ColoredPoint2D(u: Int, v: Int, c: String)
extends Point2D(u, v) {
var color = c;
def setColor(newCol: String): Unit = color = newCol;
}
14. Mixin class composition example
ColoredPoint2D
Point2D
class Point3D(xc: Int, yc: Int, zc: Int)
extends Point2D(xc, yc) {
val z = zc;
// code for manipulating Point3Ds
}
Point3D
class ColoredPoint3D(xc: Int, yc: Int, zc: Int, col: String)
extends Point3D(xc, yc, zc)
with ColoredPoint2D(xc, yc, col);
ColoredPoint3D
ColoredPoint2D
15. Mixin class composition
Mixin composition adds members explicitly
defined in ColoredPoint2D
(members that weren’t inherited)
Mixing a class C into another class D is legal
only as long as D’s superclass is a subclass of
C’s superclass.
i.e., D must inherit at least everything that C
inherited
Why?
16. Mixin class composition
Remember that only members explicitly
defined in ColoredPoint2D are mixin
inherited
So, if those members refer to definitions
that were inherited from Point2D, they had
better exist in ColoredPoint3D
They do, since
ColoredPoint3D extends Point3D
which extends Point2D
17. Views
Defines a coercion from one type to another
Similar to conversion operators in C++/C#
trait Set {
def include(x: int): Set;
def contains(x: int): boolean
}
def view(list: List) : Set = new Set {
def include(x: int): Set = x prepend xs;
def contains(x: int): boolean =
!isEmpty &&
(list.head == x || list.tail contains x)
}
18. Views
Views are inserted automatically by the Scala
compiler
If e is of type T then a view is applied to e if:
expected type of e is not T (or a supertype)
a member selected from e is not a member of T
Compiler uses only views in scope
Suppose xs : List and view above is in scope
val s: Set = xs;
xs contains x
val s: Set = view(xs);
view(xs) contains x
20. Compound types
In Java, the “solution” is:
interface CloneableAndResetable extends
Cloneable, Resetable
But if the original object did not use the
CloneableAndResetable interface, it won’t
work
Scala solution: use compound types (also
called intersection types)
def cloneAndReset(obj: Cloneable with Resetable):
Cloneable = {
...
}
21. Variance annotations
class Array[a] {
def get(index: int): a
def set(index: int, elem: a): unit;
}
Array[String] is not a subtype of Array[Any]
If it were, we could do this:
val x = new Array[String](1);
val y : Array[Any] = x;
y.set(0, new FooBar());
// just stored a FooBar in a String array!
22. Variance Annotations
Covariance is ok with functional data structures
trait GenList[+T] {
def isEmpty: boolean;
def head: T;
def tail: GenList[T]
}
object Empty extends GenList[All] {
def isEmpty: boolean = true;
def head: All = throw new Error("Empty.head");
def tail: List[All] = throw new Error("Empty.tail");
}
class Cons[+T](x: T, xs: GenList[T]) extends GenList[T] {
def isEmpty: boolean = false;
def head: T = x;
def tail: GenList[T] = xs
}
23. Variance Annotations
Can also have contravariant type parameters
Useful for an object that can only be written to
Scala checks that variance annotations are
sound
covariant positions: immutable field types,
method results
contravariant: method argument types
Type system ensures that covariant
parameters are only used covariant positions
(similar for contravariant)
24. Types as members
abstract class AbsCell {
type T;
val init: T;
private var value: T = init;
def get: T = value;
def set(x: T): unit = { value = x }
}
def createCell : AbsCell {
new AbsCell { type T = int; val init = 1 }
}
Clients of createCell cannot rely on the fact that
T is int, since this information is hidden from them
25. Discussion/Critiques
Scala has nominal subtyping. Is this good?
Inheritance and subtyping are conflated in
Scala. Shouldn’t they be separated?
Mixins in MzScheme vs. Scala – MzScheme
allows a class to parameterize its supertype,
while Scala does not
Type system does not distinguish null
references from non-null references