Research
Download
1 / 46

TeSLa - PowerPoint PPT Presentation


  • 175 Views
  • Uploaded on

research. product. TeSLa. Why The [email protected]#%! Visual Basic. Imports SySTem.STriNg Module Demo Public Sub Main() Dim S = Join( ", " , { "Hello" , "World" }) End Sub End Module. Case insensitive. Class imports. Static class. Why The [email protected]#%! Visual Basic. Class Dog

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about ' TeSLa' - fayola


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

research

product

TeSLa


Why The [email protected]#%! Visual Basic

Imports SySTem.STriNg

Module Demo

Public Sub Main()Dim S = Join(", ", { "Hello", "World"})

End Sub

End Module

Case insensitive

Class imports

Static class


Why The [email protected]#%! Visual Basic

Class Dog

Public Event Bark()End Class

Dim WithEvents D As New Dog()

Sub OnBark() Handles D.Bark Console.WriteLine("Call 911")

End Sub

DeclarativeEvent Handling

"AOP"


Why The [email protected]#%! Visual Basic

Optional parameters

Function F(X As Integer, _Optional Flag As Boolean = False) _As String …End Function

F (Flag := True, X := 4711)

Named arguments


Why The [email protected]#%! Visual Basic

Class Dog

Public Event Bark()Public Default Property Toys(Name As String) _As ObjectGet… End GetSet (Value As Object) …End Set End PropertyEnd Class

Line continuations

Indexed Properties


Why The [email protected]#%! Visual Basic

With Statement

Dim D As New Dog()

With D

.Toys("Bone") = New Bone() .Toys!Cat = CatchNeighboursCat() Console.WriteLine(.Toys("Ball").Color)

End With

Late binding

Late binding

With Scope(Power is in the ".")


Late Binding

K = J+3

For I=0 To 10

Console.WriteLine(I)Next

Dim X As String = 4711

Function F(X) Return X+3End Function

Option Implicit

Implicit Explicit Conversions

Types Optional


Relaxed delegates

DimWithEvents B As New Button()Sub OnClick(sender As Object, e As EventArgs) _Handles B.Click

End SubSub RelaxedOnClick(sender As Object, e As Object) _ Handles B.Click End Sub

Can call it  can handle it


Relaxed delegates

DelegateFunction F(A As S) As T

Function G(B As P) As Q

New F(AddressOf G)

New F(Function(A)CType(G(CType(A,P)),T)

Conversion stub


Why The [email protected]#%! Visual Basic

Extension Methods

<Runtime.CompilerServices.Extension()> _

Function FindName(Source As Object, Name As String) As Object

On Error Resume Next

If Source.Name = Name Then

Return Source

End If

Dim Children As Object = Source.Children

If Children IsNot Nothing Then

For Each Child As Object In Children

FindName = FindName(Child, Name)

If FindName IsNot Nothing Then

Return FindName

End If

Next

End If

Return Nothing

End Function

Unstructured Exception Handling

Late binding

"AOP"


Late Binding!

Type Rule For Early-BoundMethod Invocation

G |- e As S ~~> e’G |- a As T ~~> a’S•m(T) As R ~~> f----------------------------------G |- e.m(a) As R ~~> f(e’,a’)


Late Binding!

Type Rule For Late-BoundMethod Invocation

G |- e As Object ~~> e’G |- a As T ~~> a’T <: Object ~~> g-----------------------------G |- e.m(a) <: Object ~~> latecall("m", e’, g(a’))


Late Binding!

Operational Semantics For Late-Bound Call

s.GetType()  S, t.GetType()  TS•m(T) <: R ~~> fR <: Object ~~> h----------------------------latecall(m,s,t)  h(f(s,t))

VB has multi-methods!


Late Binding

Class A Sub F(X As String)WriteLine("F(String)") End Sub Sub F(X As Object)WriteLine("F(Object)") End Sub Sub Main() Dim A = New A() Dim S As Object ="Hello"A.F(S)REM Early  F(Object)CObj(A).F(S)REM Late  F(String) End Sub

End Class

Imports System.Console

Type Inference


Meta-circular interpreter

ℰ[A+B]

=

Add(ℰ[A], ℰ[B])

ℰ[A.m(B) ]

=

Call(ℰ[ m ], ℰ[A], ℰ[B])

Self interpretation is litmus test for dynamic language


Replace Constants By Variables

G |- e <: Object ~~> e’G |- a <: T ~~> a’T <: Object ~~> f

G |- m <: String ~~> m'------------------------------------------------------G |- e.(m)(a) <: Object ~~> latecall(m', e’, f(a’))

Later binding


Later Binding

Class A Sub F(X As String)WriteLine("F(String)") End Sub Sub F(X As Object)WriteLine("F(Object)") End Sub Sub Main() Dim A = New A() Dim S As Object ="Hello"A.(Console.ReadLine())(S) End Sub

End Class


VB as the ultimate scripting language

Static Typing Where PossibleDynamic Typing Where Necessary


Ruby

e = 8 + 9 \

+ 10

d = 4 + 5 +

6 + 7

def options(a=99, b=a+1) [a,b]end

redirect_to :action => 'show', :id => 4711

Line continuation

Smart "inference"

Default arguments

Named arguments via hashes


LINQ Project

== monad comprehensions in C# & VB

VB 9

C# 3.0

StandardQueryOperators

DLinq(relational)

XLinq(xml)

LINQ Framework


The Origins of LINQ

Swartz, SETL 1970; Burstall and Darlington, NPL 1977; Turner, KRC 1981; …. Haskell, Python, Scala, …

Write programs using mathematical ZF set comprehensions syntax.

Wadler 1989

List comprehensions are related to the relational calculus.

Wadler 1992

List comprehensions are a special case of monad comprehensions.


HaskellDb

Query Monad (1997)

SELECT X.FirstName, X.LastName

FROM Authors AS X

WHERE X.City = 'OakLand'

oaklands = do{ x <- table authors

; restrict (x!city .==. constant "Oakland")

; project ( au_fname = x!au_fname

, au_lname = x!au_lname )

}

Query monad

intentional representation for expressions


Query Comprensions In C# 3.0

var contacts =

from c in customers

where c.State == "WA"

selectnew { c.Name, c.Phone };

var contacts =

customers

.Where(c => c.State == "WA")

.Select(c => new{c.Name, c.Phone});

Type inference

Syntactic sugar over standard query operations

-expression


Query Comprensions In Visual Basic 9

Dim Squares = From N In Range(0,99) Select N*N

Dim Pairs = From N In Range(0,9) From C In "ABCDEFGHIJ" Select N, C

Dim Evens = From N In (0,99)Where N Mod 2 = 0Select N

Dim ByDigit = From N In (0,99)Group By N Mod 10Select Key, It


In Visual Basic 9

Dim Contacts =

From C In Customers

Where C.State = "WA"

Select C.Name, C.Phone

Dim Contacts = _

Customers. Where(Function(C) C.State = "WA"). Select(New With { .Name = C.Name, .Phone = C.Phone })


Query Comprensions In Visual Basic 9

Dim MyCDs As IEnumerable(Of _ { Title As String, Artist As String }) = _

From CD In MyMusic

Where CD.Genre IsNot Classic

Group By Genre = CD.Genre

Where Count(CD) > 10 Select Group(CD.Title, CD.Artist)

Aggregate comprehensions


Query Comprehensions

Xs.SelectMany((X) _ F(X).Select((Y)_New {X,Y}))

X

From Y In F(X)

Compiled To Standard Query Operators

X,Y

Joined


Query Comprehensions

XYs.OrderBy((XY) _ F(XY.X, XY.Y))

X,Y

Order By F(X,Y)

X,Y

Sorted


Query Comprehensions

X,Y

XYs.Where((XY) _ P(XY.X, XY.Y))

Where P(X,Y)

X,Y

Filtered


Query Comprehensions

X,Y

projected

Select A =F(X,Y), B = G(X,Y)

A,B

XYs.Select((XY) _ New {A = F(XY.X, XY.Y), _ B = F(XY.X, XY.Y) })


Query Comprehensions

XYs.GroupBy((XY) _ New {A = G(XY.X, XY.Y), _ B = H(XY.X, XY.Y) })

X,Y

Group By A = G(X,Y), B = H(X,Y)

A,B,

grouped

X,Y


Extension Methods

static classInteger {

static void Times

(this int x, Action<int> f){

for(var i = 0; i < x; i++) f(i);

}

3.Times((x) => {Console.WriteLine(x);

}


Extension Methods

IEnumerable<Customer>

var contacts =

customers

.Where(c => c.State == "WA")

.Select(c => new{c.Name, c.Phone});

static class System.Query

{

public static IEnumerable<T> Where<T>(this IEnumerable<T> src, Func<T, bool>> p);

}

Extension method for IEnumerable<T>


In Visual Basic 9

Dim Contacts = _ Customers.Where(P).Select(R)

Module MyExtensions<Runtime.CompilerServices.Extension()> _

Function Where(Of T)( _ [Me] As IEnumerable(Of T), _ P As Func(Of T, Boolean)) _As IEnumerable(Of T)

End Module

Just CA


Expression Trees

Table<Customer>

var contacts =

customers

.Where(c => c.State == "WA")

.Select(c => new{c.Name, c.Phone});

class Table<T>: IEnumerable<T>

{

public Table<T> Where(Expression <Func<T, bool>> p);

}

Intensional representation of delegate


Expression Trees

Convert to expression tree by type

Dim F As Expr = Function(X)X+3Dim G = F.Compile()Dim Z = G(5)

Compile to delegate

Execute


Anonymous types,Object initializers

var contacts =

from c in customers

where c.State == "WA"

selectnew { c.Name, c.Phone };

var Joe = new Person{ Name = “Joe”, Age = 42, Address = { Street = “1th St”, City = “Seattle” }}

Anonymous types

Object Initializers

Initialize RO member


In Visual Basic 9

Dim Contacts As IEnumerable(Of _ { Name As String, Phone As Integer } =

From c In customers _

Where C.State == "WA“ _

Select c.Name, c.Phone

Dim Joe As Person = New With { _ .Name = “Joe”, .Age = 42, _ Address With { _ .Street = “1th St”, .City = “Seattle” }}

Anonymous types

Syntax new


Nullable

Dim S1 As String? = Nothing

Dim S2 As String? = “Hello”

Dim S3 = S1+S2

Null propagating +

In VB Nothing is default


XML DOM

Dim PO As New XmlDocument

Dim purchaseOrder As XmlElement = _

PO.CreateElement("purchaseOrder")

PO.AppendChild(purchaseOrder)

Dim orderDate As XmlAttribute = PO.CreateAttribute("orderDate")

orderDate.Value = "1999-10-20"

purchaseOrder.Attributes.Append(orderDate)

Dim shipTo As XmlElement = PO.CreateElement("shipTo")

purchaseOrder.AppendChild(shipTo)

Dim country As XmlAttribute = PO.CreateAttribute("country")

country.Value = "US"

shipTo.Attributes.Append(country)

What does this program do?


XLinq API

Functional (expression-based) construction

Dim Item = _New XElement("item", _

New XAttribute("partNum", "926-AA"), _

New XElement("productName", “…"), _

New XElement("quantity", 1), _

New XElement("price", 39.98), _

New XElement("shipDate", "1999-05-21"))))

Context-free (no document scope)

Simple


Haskell Server Pages

XHTML Literals (1998)

table :: TABLE

table = <TABLE border="1"> <% mkRows cells %> </TABLE>

cells :: [[(Int,Int)]]

cells = [[ (x,y) | x <- [1..16] ] | y <- [1..16] ]

mkRows :: [[(Int,Int)]] -> [TR]

mkRows = map $ \cs -> <TR><% mkColums cs %></TR>

mkColumns :: [(Int,Int)] -> [TD]

mkColums = map $ \c -> <TD bgcolor=(color c)><% c %></TD>

Translated to universal DOM representation

ASP-style embedding


Dim PO = <purchaseOrder orderDate=(System.DateTime.Today)>

<shipTo country="US">

<name>Alice Smith</name>

<street>123 Maple Street</street>

<city>Mill Valley</city>

<state>CA</state>

<zip>90952</zip>

</shipTo>

<%= BillTo %>

<items>

<%=

Select<itempartNum=<%= O.PartID %>>

<productName>

<%= O.Product %>

</productName>

<quantity>

<%= O.Quantity %>

</quantity>

<price>

<%= O.Price %>

</price>

</item>

From O In Orders

Where O.Name = "Robert Smith"

%>

</items>

</purchaseOrder>

Translated to XLinq constructor calls

ASP-style embedding

Includes full namespace support


Late binding over XML

Child axis

BillTo.<street>  BillTo.Elements(“street”)

Attribute axis

[email protected] BillTo.Attributes(“country”)

Descendants axis PO...<item>  PO.Descendants(“item”)


Tesla

  • Tools & IDE

  • Type system & Language extensions

  • Runtime & Library support

  • Transactions everywhere


Conclusion

VB IsNot C#

VB = static typing where possible, dynamic typing where necessary.


ad